home *** CD-ROM | disk | FTP | other *** search
/ LG Super CD / LG Super CD.iso / bitpim / bitpim-0.62-setup.exe / {app} / bitpim.exe / profile.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2003-11-06  |  13.7 KB  |  387 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.3)
  3.  
  4. import sys
  5. import os
  6. import time
  7. import marshal
  8. __all__ = [
  9.     'run',
  10.     'help',
  11.     'Profile']
  12.  
  13. def run(statement, filename = None):
  14.     prof = Profile()
  15.     
  16.     try:
  17.         prof = prof.run(statement)
  18.     except SystemExit:
  19.         pass
  20.  
  21.     if filename is not None:
  22.         prof.dump_stats(filename)
  23.     else:
  24.         return prof.print_stats()
  25.  
  26.  
  27. def help():
  28.     for dirname in sys.path:
  29.         fullname = os.path.join(dirname, 'profile.doc')
  30.         if os.path.exists(fullname):
  31.             sts = os.system('${PAGER-more} ' + fullname)
  32.             if sts:
  33.                 print '*** Pager exit status:', sts
  34.             
  35.             break
  36.             continue
  37.     else:
  38.         print 'Sorry, can\'t find the help file "profile.doc"', 'along the Python search path.'
  39.  
  40. if os.name == 'mac':
  41.     import MacOS
  42.     
  43.     def _get_time_mac(timer = MacOS.GetTicks):
  44.         return timer() / 60.0
  45.  
  46.  
  47. if hasattr(os, 'times'):
  48.     
  49.     def _get_time_times(timer = os.times):
  50.         t = timer()
  51.         return t[0] + t[1]
  52.  
  53.  
  54.  
  55. class Profile:
  56.     bias = 0
  57.     
  58.     def __init__(self, timer = None, bias = None):
  59.         self.timings = { }
  60.         self.cur = None
  61.         self.cmd = ''
  62.         if bias is None:
  63.             bias = self.bias
  64.         
  65.         self.bias = bias
  66.         if timer is None:
  67.             if os.name == 'mac':
  68.                 self.timer = MacOS.GetTicks
  69.                 self.dispatcher = self.trace_dispatch_mac
  70.                 self.get_time = _get_time_mac
  71.             elif hasattr(time, 'clock'):
  72.                 self.timer = self.get_time = time.clock
  73.                 self.dispatcher = self.trace_dispatch_i
  74.             elif hasattr(os, 'times'):
  75.                 self.timer = os.times
  76.                 self.dispatcher = self.trace_dispatch
  77.                 self.get_time = _get_time_times
  78.             else:
  79.                 self.timer = self.get_time = time.time
  80.                 self.dispatcher = self.trace_dispatch_i
  81.         else:
  82.             self.timer = timer
  83.             t = self.timer()
  84.             
  85.             try:
  86.                 length = len(t)
  87.             except TypeError:
  88.                 self.get_time = timer
  89.                 self.dispatcher = self.trace_dispatch_i
  90.  
  91.             if length == 2:
  92.                 self.dispatcher = self.trace_dispatch
  93.             else:
  94.                 self.dispatcher = self.trace_dispatch_l
  95.             import operator
  96.             
  97.             def get_time_timer(timer = timer, reduce = reduce, reducer = operator.add):
  98.                 return reduce(reducer, timer(), 0)
  99.  
  100.             self.get_time = get_time_timer
  101.         self.t = self.get_time()
  102.         self.simulate_call('profiler')
  103.  
  104.     
  105.     def trace_dispatch(self, frame, event, arg):
  106.         timer = self.timer
  107.         t = timer()
  108.         t = t[0] + t[1] - self.t - self.bias
  109.         if self.dispatch[event](self, frame, t):
  110.             t = timer()
  111.             self.t = t[0] + t[1]
  112.         else:
  113.             r = timer()
  114.             self.t = r[0] + r[1] - t
  115.  
  116.     
  117.     def trace_dispatch_i(self, frame, event, arg):
  118.         timer = self.timer
  119.         t = timer() - self.t - self.bias
  120.         if self.dispatch[event](self, frame, t):
  121.             self.t = timer()
  122.         else:
  123.             self.t = timer() - t
  124.  
  125.     
  126.     def trace_dispatch_mac(self, frame, event, arg):
  127.         timer = self.timer
  128.         t = timer() / 60.0 - self.t - self.bias
  129.         if self.dispatch[event](self, frame, t):
  130.             self.t = timer() / 60.0
  131.         else:
  132.             self.t = timer() / 60.0 - t
  133.  
  134.     
  135.     def trace_dispatch_l(self, frame, event, arg):
  136.         get_time = self.get_time
  137.         t = get_time() - self.t - self.bias
  138.         if self.dispatch[event](self, frame, t):
  139.             self.t = get_time()
  140.         else:
  141.             self.t = get_time() - t
  142.  
  143.     
  144.     def trace_dispatch_exception(self, frame, t):
  145.         (rpt, rit, ret, rfn, rframe, rcur) = self.cur
  146.         if rframe is not frame and rcur:
  147.             return self.trace_dispatch_return(rframe, t)
  148.         
  149.         self.cur = (rpt, rit + t, ret, rfn, rframe, rcur)
  150.         return 1
  151.  
  152.     
  153.     def trace_dispatch_call(self, frame, t):
  154.         if self.cur and frame.f_back is not self.cur[-2]:
  155.             (rpt, rit, ret, rfn, rframe, rcur) = self.cur
  156.             if not isinstance(rframe, Profile.fake_frame):
  157.                 self.trace_dispatch_return(rframe, 0)
  158.             
  159.         
  160.         fcode = frame.f_code
  161.         fn = (fcode.co_filename, fcode.co_firstlineno, fcode.co_name)
  162.         self.cur = (t, 0, 0, fn, frame, self.cur)
  163.         timings = self.timings
  164.         if fn in timings:
  165.             (cc, ns, tt, ct, callers) = timings[fn]
  166.             timings[fn] = (cc, ns + 1, tt, ct, callers)
  167.         else:
  168.             timings[fn] = (0, 0, 0, 0, { })
  169.         return 1
  170.  
  171.     
  172.     def trace_dispatch_return(self, frame, t):
  173.         if frame is not self.cur[-2]:
  174.             self.trace_dispatch_return(self.cur[-2], 0)
  175.         
  176.         (rpt, rit, ret, rfn, frame, rcur) = self.cur
  177.         rit = rit + t
  178.         frame_total = rit + ret
  179.         (ppt, pit, pet, pfn, pframe, pcur) = rcur
  180.         self.cur = (ppt, pit + rpt, pet + frame_total, pfn, pframe, pcur)
  181.         timings = self.timings
  182.         (cc, ns, tt, ct, callers) = timings[rfn]
  183.         if not ns:
  184.             ct = ct + frame_total
  185.             cc = cc + 1
  186.         
  187.         if pfn in callers:
  188.             callers[pfn] = callers[pfn] + 1
  189.         else:
  190.             callers[pfn] = 1
  191.         timings[rfn] = (cc, ns - 1, tt + rit, ct, callers)
  192.         return 1
  193.  
  194.     dispatch = {
  195.         'call': trace_dispatch_call,
  196.         'exception': trace_dispatch_exception,
  197.         'return': trace_dispatch_return }
  198.     
  199.     def set_cmd(self, cmd):
  200.         if self.cur[-1]:
  201.             return None
  202.         
  203.         self.cmd = cmd
  204.         self.simulate_call(cmd)
  205.  
  206.     
  207.     class fake_code:
  208.         
  209.         def __init__(self, filename, line, name):
  210.             self.co_filename = filename
  211.             self.co_line = line
  212.             self.co_name = name
  213.             self.co_firstlineno = 0
  214.  
  215.         
  216.         def __repr__(self):
  217.             return repr((self.co_filename, self.co_line, self.co_name))
  218.  
  219.  
  220.     
  221.     class fake_frame:
  222.         
  223.         def __init__(self, code, prior):
  224.             self.f_code = code
  225.             self.f_back = prior
  226.  
  227.  
  228.     
  229.     def simulate_call(self, name):
  230.         code = self.fake_code('profile', 0, name)
  231.         if self.cur:
  232.             pframe = self.cur[-2]
  233.         else:
  234.             pframe = None
  235.         frame = self.fake_frame(code, pframe)
  236.         self.dispatch['call'](self, frame, 0)
  237.  
  238.     
  239.     def simulate_cmd_complete(self):
  240.         get_time = self.get_time
  241.         t = get_time() - self.t
  242.         while self.cur[-1]:
  243.             self.dispatch['return'](self, self.cur[-2], t)
  244.             t = 0
  245.         self.t = get_time() - t
  246.  
  247.     
  248.     def print_stats(self):
  249.         import pstats
  250.         pstats.Stats(self).strip_dirs().sort_stats(-1).print_stats()
  251.  
  252.     
  253.     def dump_stats(self, file):
  254.         f = open(file, 'wb')
  255.         self.create_stats()
  256.         marshal.dump(self.stats, f)
  257.         f.close()
  258.  
  259.     
  260.     def create_stats(self):
  261.         self.simulate_cmd_complete()
  262.         self.snapshot_stats()
  263.  
  264.     
  265.     def snapshot_stats(self):
  266.         self.stats = { }
  267.         for cc, ns, tt, ct, callers in self.timings.iteritems():
  268.             callers = callers.copy()
  269.             nc = 0
  270.             for callcnt in callers.itervalues():
  271.                 nc += callcnt
  272.             
  273.             self.stats[func] = (cc, nc, tt, ct, callers)
  274.         
  275.  
  276.     
  277.     def run(self, cmd):
  278.         import __main__
  279.         dict = __main__.__dict__
  280.         return self.runctx(cmd, dict, dict)
  281.  
  282.     
  283.     def runctx(self, cmd, globals, locals):
  284.         self.set_cmd(cmd)
  285.         sys.setprofile(self.dispatcher)
  286.         
  287.         try:
  288.             exec cmd in globals, locals
  289.         finally:
  290.             sys.setprofile(None)
  291.  
  292.         return self
  293.  
  294.     
  295.     def runcall(self, func, *args, **kw):
  296.         self.set_cmd(`func`)
  297.         sys.setprofile(self.dispatcher)
  298.         
  299.         try:
  300.             return func(*args, **kw)
  301.         finally:
  302.             sys.setprofile(None)
  303.  
  304.  
  305.     
  306.     def calibrate(self, m, verbose = 0):
  307.         if self.__class__ is not Profile:
  308.             raise TypeError('Subclasses must override .calibrate().')
  309.         
  310.         saved_bias = self.bias
  311.         self.bias = 0
  312.         
  313.         try:
  314.             return self._calibrate_inner(m, verbose)
  315.         finally:
  316.             self.bias = saved_bias
  317.  
  318.  
  319.     
  320.     def _calibrate_inner(self, m, verbose):
  321.         get_time = self.get_time
  322.         
  323.         def f1(n):
  324.             for i in range(n):
  325.                 x = 1
  326.             
  327.  
  328.         
  329.         def f(m, f1 = f1):
  330.             for i in range(m):
  331.                 f1(100)
  332.             
  333.  
  334.         f(m)
  335.         t0 = get_time()
  336.         f(m)
  337.         t1 = get_time()
  338.         elapsed_noprofile = t1 - t0
  339.         if verbose:
  340.             print 'elapsed time without profiling =', elapsed_noprofile
  341.         
  342.         p = Profile()
  343.         t0 = get_time()
  344.         p.runctx('f(m)', globals(), locals())
  345.         t1 = get_time()
  346.         elapsed_profile = t1 - t0
  347.         if verbose:
  348.             print 'elapsed time with profiling =', elapsed_profile
  349.         
  350.         total_calls = 0.0
  351.         reported_time = 0.0
  352.         for filename, line, funcname in p.timings.items():
  353.             (cc, ns, tt, ct, callers) = None
  354.             if funcname in ('f', 'f1'):
  355.                 total_calls += cc
  356.                 reported_time += tt
  357.                 continue
  358.         
  359.         if verbose:
  360.             print "'CPU seconds' profiler reported =", reported_time
  361.             print 'total # calls =', total_calls
  362.         
  363.         if total_calls != m + 1:
  364.             raise ValueError('internal error: total calls = %d' % total_calls)
  365.         
  366.         mean = (reported_time - elapsed_noprofile) / 2.0 / total_calls
  367.         if verbose:
  368.             print 'mean stopwatch overhead per profile event =', mean
  369.         
  370.         return mean
  371.  
  372.  
  373.  
  374. def Stats(*args):
  375.     print 'Report generating functions are in the "pstats" module\x07'
  376.  
  377. if __name__ == '__main__':
  378.     if not sys.argv[1:]:
  379.         print 'usage: profile.py scriptfile [arg] ...'
  380.         sys.exit(2)
  381.     
  382.     filename = sys.argv[1]
  383.     del sys.argv[0]
  384.     sys.path.insert(0, os.path.dirname(filename))
  385.     run('execfile(' + `filename` + ')')
  386.  
  387.